/**
 * OCR服务模块 - 处理图片识别功能
 * 对接后端 /api/ocr 接口
 */

import { upload, post } from './request.js'

/**
 * OCR识别服务类
 */
class OCRService {
  constructor() {
    this.baseUrl = '/api/ocr'
  }

  /**
   * 药品OCR识别
   * @param {string} imagePath 图片本地路径
   * @param {Object} options 识别选项
   * @returns {Promise<Object>} OCR识别结果
   */
  async recognizeDrug(imagePath, options = {}) {
    try {
      console.log('开始药品OCR识别:', imagePath)
      
      const result = await upload(
        `${this.baseUrl}/recognize/drug`,
        imagePath,
        {
          name: 'image', // 后端接收的字段名
          formData: {
            parallel: options.parallel || false, // 是否使用并行识别
            ...options.extraData
          },
          timeout: 30000, // 30秒超时
          header: {
            'content-type': 'multipart/form-data'
          }
        }
      )

      console.log('OCR服务返回结果:', {
        success: result.success,
        message: result.message,
        dataKeys: result.data ? Object.keys(result.data) : 'no data'
      })
      
      if (result.success) {
        console.log('OCR识别成功:', result.data)
        return {
          success: true,
          data: {
            originalFile: result.data.originalFile,
            text: result.data.text || '',
            confidence: result.data.confidence || 0,
            drugInfo: result.data.drugInfo || {},
            recognitionMode: result.data.recognitionMode || 'single',
            words: result.data.words || [],
            serviceUsed: this.getServiceName(result.message || '')
          },
          message: result.message
        }
      } else {
        console.error('OCR识别失败，后端返回:', result)
        throw new Error(result.message || 'OCR识别失败')
      }
    } catch (error) {
      console.error('药品OCR识别失败:', error)
      console.error('错误详情:', {
        name: error.name,
        message: error.message,
        stack: error.stack
      })
      
      // 返回友好的错误信息
      return {
        success: false,
        error: error.message,
        data: null
      }
    }
  }

  /**
   * 通用文字识别
   * @param {string} imagePath 图片本地路径
   * @param {Object} options 识别选项
   * @returns {Promise<Object>} OCR识别结果
   */
  async recognizeText(imagePath, options = {}) {
    try {
      console.log('开始通用文字识别:', imagePath)
      
      const result = await upload(
        `${this.baseUrl}/recognize`,
        imagePath,
        {
          name: 'image',
          formData: options.extraData || {},
          timeout: 30000,
          header: {
            'content-type': 'multipart/form-data'
          }
        }
      )

      if (result.success) {
        console.log('文字识别成功:', result.data)
        return {
          success: true,
          data: {
            originalFile: result.data.originalFile,
            text: result.data.text || '',
            confidence: result.data.confidence || 0,
            words: result.data.words || [],
            serviceUsed: this.getServiceName(result.message)
          },
          message: result.message
        }
      } else {
        throw new Error(result.message || '文字识别失败')
      }
    } catch (error) {
      console.error('通用文字识别失败:', error)
      
      return {
        success: false,
        error: error.message,
        data: null
      }
    }
  }

  /**
   * 获取OCR配置信息
   * @returns {Promise<Object>} OCR配置
   */
  async getOCRConfig() {
    try {
      const result = await post(`${this.baseUrl}/config`)
      return result
    } catch (error) {
      console.error('获取OCR配置失败:', error)
      return {
        success: false,
        error: error.message
      }
    }
  }

  /**
   * 更新OCR配置
   * @param {Object} config 新的配置
   * @returns {Promise<Object>} 更新结果
   */
  async updateOCRConfig(config) {
    try {
      const result = await post(`${this.baseUrl}/config`, config)
      return result
    } catch (error) {
      console.error('更新OCR配置失败:', error)
      return {
        success: false,
        error: error.message
      }
    }
  }

  /**
   * 解析服务名称
   * @param {string} message 返回消息
   * @returns {string} 服务名称
   */
  getServiceName(message) {
    if (message.includes('百度AI')) return 'baidu'
    if (message.includes('阿里云')) return 'aliyun'
    if (message.includes('Tesseract')) return 'tesseract'
    if (message.includes('PP-OCR')) return 'ppocr'
    if (message.includes('演示模式')) return 'mock'
    return 'unknown'
  }

  /**
   * 图片预处理（可选）
   * @param {string} imagePath 图片路径
   * @returns {Promise<string>} 处理后的图片路径
   */
  async preprocessImage(imagePath) {
    // 这里可以添加图片预处理逻辑
    // 例如：压缩、裁剪、滤镜等
    return imagePath
  }

  /**
   * 验证图片格式和大小
   * @param {Object} file 文件信息
   * @returns {Object} 验证结果
   */
  validateImage(file) {
    const maxSize = 10 * 1024 * 1024 // 10MB
    const allowedTypes = ['jpg', 'jpeg', 'png', 'bmp', 'webp']
    
    // 检查文件大小
    if (file.size && file.size > maxSize) {
      return {
        valid: false,
        message: '图片文件不能超过10MB'
      }
    }

    // 检查文件格式
    const extension = file.name ? file.name.split('.').pop().toLowerCase() : ''
    if (extension && !allowedTypes.includes(extension)) {
      return {
        valid: false,
        message: '只支持 JPG、PNG、BMP、WebP 格式的图片'
      }
    }

    return {
      valid: true,
      message: '图片验证通过'
    }
  }

  /**
   * 药品信息智能解析
   * @param {string} text OCR识别的文字
   * @returns {Object} 解析后的药品信息
   */
  parseDrugInfo(text) {
    const drugInfo = {
      name: '',
      specification: '',
      manufacturer: '',
      batchNumber: '',
      expiryDate: '',
      approvalNumber: ''
    }

    // 简单的正则解析示例
    // 实际项目中可以使用更复杂的NLP算法

    // 药品名称（通常在开头或标题位置）
    const nameMatch = text.match(/^([^\d\n]+)/)
    if (nameMatch) {
      drugInfo.name = nameMatch[1].trim()
    }

    // 规格（包含数字和单位）
    const specMatch = text.match(/(\d+(?:\.\d+)?(?:mg|g|ml|粒|片|支|瓶))/i)
    if (specMatch) {
      drugInfo.specification = specMatch[1]
    }

    // 生产企业
    const manufacturerMatch = text.match(/(?:生产企业|制造商)[:：]?\s*([^\n]+)/)
    if (manufacturerMatch) {
      drugInfo.manufacturer = manufacturerMatch[1].trim()
    }

    // 批号
    const batchMatch = text.match(/(?:批号|批次)[:：]?\s*([A-Z0-9]+)/)
    if (batchMatch) {
      drugInfo.batchNumber = batchMatch[1]
    }

    // 有效期
    const expiryMatch = text.match(/(?:有效期|保质期)[:：]?\s*(\d{4}[-./]\d{1,2}[-./]\d{1,2})/)
    if (expiryMatch) {
      drugInfo.expiryDate = expiryMatch[1]
    }

    // 批准文号
    const approvalMatch = text.match(/(国药准字[A-Z]\d{8})/)
    if (approvalMatch) {
      drugInfo.approvalNumber = approvalMatch[1]
    }

    return drugInfo
  }
}

// 创建单例实例
const ocrService = new OCRService()

export default ocrService

// 导出常用方法
export const {
  recognizeDrug,
  recognizeText,
  getOCRConfig,
  updateOCRConfig,
  validateImage,
  parseDrugInfo
} = ocrService